﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.Xml;

namespace MDF
{
    class IO_xml
    {

        private string xmlName;
        private string xmlPath;
        private XmlDocument xmldoc;
        /// <summary>
        /// 初始化构造函数
        /// </summary>
        /// <param name="name">xml文件名</param>
        public IO_xml(string name)
        {
            xmlName = name;
            xmlPath = Application.StartupPath +"\\Sys\\"+ name + ".xml";
            xmldoc = new XmlDocument();//实例化xml对象
            Create_XmlFile();
        }
        /// <summary>
        /// 创建对应xml文件
        /// </summary>
        private void Create_XmlFile()
        {
            try
            {
                //判断xml文件是否存在，不存在时，进行创建
                if (!File.Exists(xmlPath))
                {
                    //加入XML的声明段落：<?xmlversion="1.0" encoding="utf-8"?>
                    XmlDeclaration xmldec = xmldoc.CreateXmlDeclaration("1.0", "utf-8", null);
                    xmldoc.AppendChild(xmldec);
                    //创建根节点
                    XmlElement root = xmldoc.CreateElement(xmlName);
                    xmldoc.AppendChild(root);
                    //保存xml文件
                    xmldoc.Save(xmlPath);
                }
                //存在时,进行加载
                else
                {
                    xmldoc.Load(xmlPath);
                }
            }
            catch (Exception)
            {

                throw;
            }
        }

        #region 写、改
        /// <summary>
        /// 信息配置（增加或修改）
        /// </summary>
        /// <param name="InfoName">信息节点名</param>
        /// <param name="DataName">数据节点名</param>
        /// <param name="Key">关键字</param>
        /// <param name="Value">数据值</param>
        public void WriteXml(string InfoName, string DataName, string Key, string Value)
        {
            try
            {
                //获取根节点
                XmlNode root = xmldoc.SelectSingleNode(xmlName);
                //获取信息节点
                XmlNode infoNode = root.SelectSingleNode(InfoName);
                //检查信息节点是否存在
                if (infoNode != null)
                {
                    //检查数据信息是否存在
                    if (infoNode.SelectSingleNode(DataName) != null)
                    {
                        //获取数据节点
                        XmlElement dataNode = (XmlElement)infoNode.SelectSingleNode(DataName);
                        //修改数据
                        dataNode.SetAttribute(Key, Value);
                    }
                    else
                    {
                        //添加数据节点
                        XmlElement datanode = xmldoc.CreateElement(DataName);
                        datanode.SetAttribute(Key, Value);
                        infoNode.AppendChild(datanode);//添加到信息节点
                    }
                }
                else
                {
                    //创建信息节点
                    XmlElement infonode = xmldoc.CreateElement(InfoName);
                    root.AppendChild(infonode);//添加到根节点
                    //添加数据节点
                    XmlElement datanode = xmldoc.CreateElement(DataName);
                    datanode.SetAttribute(Key, Value);
                    infonode.AppendChild(datanode);//添加到信息节点
                }
                //保存xml文件
                xmldoc.Save(xmlPath);
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 信息配置（增加或修改）
        /// </summary>
        /// <param name="InfoName">信息节点名</param>
        /// <param name="DataName">数据节点名</param>
        /// <param name="Keys">关键字数组</param>
        /// <param name="Values">数据值数组</param>
        public void WriteXml(string InfoName, string DataName, string[] Keys, string[] Values)
        {
            try
            {
                //获取根节点
                XmlNode root = xmldoc.SelectSingleNode(xmlName);
                //获取信息节点
                XmlNode infoNode = root.SelectSingleNode(InfoName);
                //检查信息节点是否存在
                if (infoNode != null)
                {
                    //检查数据信息是否存在
                    if (infoNode.SelectSingleNode(DataName) != null)
                    {
                        //获取数据节点
                        XmlElement dataNode = (XmlElement)infoNode.SelectSingleNode(DataName);
                        //修改数据
                        for (int i = 0; i < Keys.Length; i++)
                        {
                            dataNode.SetAttribute(Keys[i], Values[i]);
                        }
                        
                    }
                    else
                    {
                        //添加数据节点
                        XmlElement datanode = xmldoc.CreateElement(DataName);
                        for (int i = 0; i < Keys.Length; i++)
                        {
                            datanode.SetAttribute(Keys[i], Values[i]);
                        }
                        infoNode.AppendChild(datanode);//添加到信息节点
                    }
                }
                else
                {
                    //创建信息节点
                    XmlElement infonode = xmldoc.CreateElement(InfoName);
                    root.AppendChild(infonode);//添加到根节点
                    //添加数据节点
                    XmlElement datanode = xmldoc.CreateElement(DataName);
                    for (int i = 0; i < Keys.Length; i++)
                    {
                        datanode.SetAttribute(Keys[i], Values[i]);
                    }
                    infonode.AppendChild(datanode);//添加到信息节点
                }
                //保存xml文件
                xmldoc.Save(xmlPath);
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 信息配置（增加或修改）
        /// </summary>
        /// <param name="InfoName">信息节点名</param>
        /// <param name="DataName">数据节点名</param>
        /// <param name="ChildName">数据子节点名</param>
        /// <param name="Keys">数据key值数组</param>
        /// <param name="Values">数据value值数组</param>
        public void WriteXml(string InfoName, string DataName, string ChildName, string[] Keys, string[] Values)
        {
            try
            {
                //获取根节点
                XmlNode root = xmldoc.SelectSingleNode(xmlName);
                //获取信息节点
                XmlNode infoNode = root.SelectSingleNode(InfoName);
                //检查信息节点是否存在
                if (infoNode != null)
                {
                    XmlNode dataNode = infoNode.SelectSingleNode(DataName);
                    //检查数据节点是否存在
                    if (dataNode != null)
                    {
                        //检查数据子节点是否存在
                        if (dataNode.SelectSingleNode(ChildName) != null)
                        {
                            //获取数据节点
                            XmlElement childNode = (XmlElement)dataNode.SelectSingleNode(ChildName);
                            //修改数据
                            for (int i = 0; i < Keys.Length; i++)
                            {
                                childNode.SetAttribute(Keys[i], Values[i]);
                            }
                        }
                        else
                        {
                            //添加数据节点
                            XmlElement childNode = xmldoc.CreateElement(ChildName);
                            for (int i = 0; i < Keys.Length; i++)
                            {
                                childNode.SetAttribute(Keys[i], Values[i]);
                            }
                            dataNode.AppendChild(childNode);//添加到信息节点
                        }

                    }
                    else
                    {
                        //添加数据节点
                        XmlElement datanode = xmldoc.CreateElement(DataName);
                        infoNode.AppendChild(datanode);//添加到信息节点
                        //添加数据子节点
                        XmlElement childnode = xmldoc.CreateElement(ChildName);
                        for (int i = 0; i < Keys.Length; i++)
                        {
                            childnode.SetAttribute(Keys[i], Values[i]);
                        }
                        datanode.AppendChild(childnode);//添加到数据节点
                    }
                }
                else
                {
                    //创建信息节点
                    XmlElement infonode = xmldoc.CreateElement(InfoName);
                    root.AppendChild(infonode);//添加到根节点
                    //添加数据节点
                    XmlElement datanode = xmldoc.CreateElement(DataName);
                    infonode.AppendChild(datanode);//添加到信息节点
                    //添加数据子节点
                    XmlElement childnode = xmldoc.CreateElement(ChildName);
                    for (int i = 0; i < Keys.Length; i++)
                    {
                        childnode.SetAttribute(Keys[i], Values[i]);
                    }
                    datanode.AppendChild(childnode);//添加到数据节点
                }
                //保存xml文件
                xmldoc.Save(xmlPath);
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 信息配置（增加或修改）
        /// </summary>
        /// <param name="InfoName">信息节点名</param>
        /// <param name="DataName">数据节点名</param>
        /// <param name="ChildNames">数据子节点名集合</param>
        /// <param name="Keys">数据key值数组</param>
        /// <param name="Values">数据value值数组</param>
        public void WriteXml(string InfoName, string DataName,string[] ChildNames, string[] Keys, string[] Values)
        {
            try
            {
                //获取根节点
                XmlNode root = xmldoc.SelectSingleNode(xmlName);
                //获取信息节点
                XmlNode infoNode = root.SelectSingleNode(InfoName);
                //检查信息节点是否存在
                if (infoNode != null)
                {
                    XmlNode dataNode = infoNode.SelectSingleNode(DataName);
                    //检查数据节点是否存在
                    if (dataNode != null)
                    {
                        //添加数据节点
                        XmlElement datanode = xmldoc.CreateElement(DataName);
                        //添加数据子节点
                        for (int i = 0; i < ChildNames.Length; i++)
                        {
                            XmlElement childnode = xmldoc.CreateElement(ChildNames[i]);
                            childnode.SetAttribute(Keys[i], Values[i]);
                            datanode.AppendChild(childnode);//添加到数据节点
                        }
                        //替换当前节点
                        infoNode.ReplaceChild(datanode, dataNode);
                    }
                    else
                    {
                        //添加数据节点
                        XmlElement datanode = xmldoc.CreateElement(DataName);
                        infoNode.AppendChild(datanode);//添加到信息节点
                        //添加数据子节点
                        for (int i = 0; i < ChildNames.Length; i++)
                        {
                            XmlElement childnode = xmldoc.CreateElement(ChildNames[i]);
                            childnode.SetAttribute(Keys[i], Values[i]);
                            datanode.AppendChild(childnode);//添加到数据节点
                        }
                       
                    }
                }
                else
                {
                    //创建信息节点
                    XmlElement infonode = xmldoc.CreateElement(InfoName);
                    root.AppendChild(infonode);//添加到根节点
                    //添加数据节点
                    XmlElement datanode = xmldoc.CreateElement(DataName);
                    infonode.AppendChild(datanode);//添加到信息节点
                    //添加数据子节点
                    for (int i = 0; i < ChildNames.Length; i++)
                    {
                        XmlElement childnode = xmldoc.CreateElement(ChildNames[i]);
                        childnode.SetAttribute(Keys[i], Values[i]);
                        datanode.AppendChild(childnode);//添加到数据节点
                    }
                }
                //保存xml文件
                xmldoc.Save(xmlPath);
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 信息配置（增加或修改）
        /// </summary>
        /// <param name="InfoName">信息节点名</param>
        /// <param name="DataName">数据节点名</param>
        /// <param name="innerText">内部文本</param>
        public void WriteXml(string InfoName, string DataName, string innerText)
        {
            try
            {
                //获取根节点
                XmlNode root = xmldoc.SelectSingleNode(xmlName);
                //获取信息节点
                XmlNode infoNode = root.SelectSingleNode(InfoName);
                //检查信息节点是否存在
                if (infoNode != null)
                {
                    //检查数据节点是否存在
                    if (infoNode.SelectSingleNode(DataName) != null)
                    {
                        //获取数据节点
                        XmlElement dataNode = (XmlElement)infoNode.SelectSingleNode(DataName);
                        //修改数据
                        dataNode.InnerText = innerText;
                    }
                    else
                    {
                        //添加数据节点
                        XmlElement datanode = xmldoc.CreateElement(DataName);
                        datanode.InnerText = innerText;
                        infoNode.AppendChild(datanode);//添加到信息节点
                    }
                }
                else
                {
                    //创建信息节点
                    XmlElement infonode = xmldoc.CreateElement(InfoName);
                    root.AppendChild(infonode);//添加到根节点
                    //添加数据节点
                    XmlElement datanode = xmldoc.CreateElement(DataName);
                    datanode.InnerText = innerText;
                    infonode.AppendChild(datanode);//添加到信息节点
                }
                //保存xml文件
                xmldoc.Save(xmlPath);
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 信息配置（增加或修改）
        /// </summary>
        /// <param name="InfoName">信息节点名</param>
        /// <param name="DataName">数据节点名</param>
        /// <param name="Key">关键字</param>
        /// <param name="Value">数据值</param>
        /// <param name="innerText">内部文本</param>
        public void WriteXml(string InfoName, string DataName, string Key, string Value,string innerText)
        {
            try
            {
                //获取根节点
                XmlNode root = xmldoc.SelectSingleNode(xmlName);
                //获取信息节点
                XmlNode infoNode = root.SelectSingleNode(InfoName);
                //检查信息节点是否存在
                if (infoNode != null)
                {
                    //检查数据节点是否存在
                    if (infoNode.SelectSingleNode(DataName) != null)
                    {
                        //获取数据节点
                        XmlElement dataNode = (XmlElement)infoNode.SelectSingleNode(DataName);
                        //修改数据
                        dataNode.SetAttribute(Key, Value);
                        dataNode.InnerText = innerText;
                    }
                    else
                    {
                        //添加数据节点
                        XmlElement datanode = xmldoc.CreateElement(DataName);
                        datanode.SetAttribute(Key, Value);
                        datanode.InnerText = innerText;
                        infoNode.AppendChild(datanode);//添加到信息节点
                    }
                }
                else
                {
                    //创建信息节点
                    XmlElement infonode = xmldoc.CreateElement(InfoName);
                    root.AppendChild(infonode);//添加到根节点
                    //添加数据节点
                    XmlElement datanode = xmldoc.CreateElement(DataName);
                    datanode.SetAttribute(Key, Value);
                    datanode.InnerText = innerText;
                    infonode.AppendChild(datanode);//添加到信息节点
                }
                //保存xml文件
                xmldoc.Save(xmlPath);
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 信息配置(修改节点)
        /// </summary>
        /// <param name="OldName"></param>
        /// <param name="NewName"></param>
        /// <param name="Key">关键字</param>
        /// <param name="Value">数据值</param>
        /// <returns>修改成功返回true，失败返回false</returns>
        public bool ReviseXml(string OldName, string NewName, string Key, string Value)
        {
            try
            {
                //先查找旧节点的位置，获取父节点
                XmlNode oldNode = xmldoc.SelectSingleNode("//" + OldName);
                XmlNode ParentNdoe = oldNode.ParentNode;
                //新建新节点
                XmlNode newNode = xmldoc.CreateElement(NewName);
                //填充子节点
                foreach (XmlNode childNode in oldNode.ChildNodes)
                {
                    newNode.AppendChild(childNode);
                }
                //替换旧节点
                XmlElement reNdoe = (XmlElement)ParentNdoe.ReplaceChild(newNode, oldNode);
                if (reNdoe != null)
                {
                    //修改节点属性
                    reNdoe.SetAttribute(Key, Value);
                    //保存xml文件
                    xmldoc.Save(xmlPath);
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception)
            {

                throw;
            }
        }

        /// <summary>
        /// 用户登陆信息配置（增加或修改）
        /// </summary>
        /// <param name="userInfoName">信息节点名</param>
        /// <param name="userName">用户名</param>
        /// <param name="password">用户密码</param>
        /// <param name="check">占位</param>
        public void WriteUsersInfo(string userInfoName, string userName, string password,string check)
        {
            try
            {
                //获取根节点
                XmlNode root = xmldoc.SelectSingleNode(xmlName);
                //获取信息节点
                XmlNode infoNode = root.SelectSingleNode(userInfoName);
                //检查信息节点是否存在
                if (infoNode != null)
                {
                    if(userInfoName == "LastLoadInfo")
                    {
                        //先清空上次登陆信息，后面再添加
                        infoNode.RemoveAll();
                    }
                    //检查用户数据是否存在
                    if (infoNode.SelectSingleNode(userName) != null)
                    {
                        //获取用户数据节点
                        XmlElement User = (XmlElement)infoNode.SelectSingleNode(userName);
                        //修改数据
                        User.SetAttribute("Password", password);
                        User.SetAttribute("Check", check);
                        
                    }
                    else
                    {
                        // 添加用户数据节点
                        XmlElement user = xmldoc.CreateElement(userName);
                        user.SetAttribute("Password", password);
                        user.SetAttribute("Check", check);
                        infoNode.AppendChild(user);//添加到信息节点
                    }
                }
                else
                {
                    //创建信息节点
                    XmlElement infonode = xmldoc.CreateElement(userInfoName);
                    root.AppendChild(infonode);//添加到根节点
                    //添加用户数据节点
                    XmlElement user = xmldoc.CreateElement(userName);
                    user.SetAttribute("Password", password);
                    user.SetAttribute("Check", check);
                    infonode.AppendChild(user);//添加到信息节点
                }
                //保存xml文件
                xmldoc.Save(xmlPath);
            }
            catch (Exception)
            {

                throw;
            }
        }

        #endregion

        #region 删除
        /// <summary>
        /// 删除指定信息节点
        /// </summary>
        /// <param name="InfoName">信息节点名</param>
        /// <returns>删除成功返回true，失败返回false</returns>
        public bool DeleteXml(string InfoName)
        {
            try
            {
                //获取根节点
                XmlNode root = xmldoc.SelectSingleNode(xmlName);
                //获取信息节点
                XmlNode infoNode = root.SelectSingleNode(InfoName);
                if (infoNode != null)
                {
                    //移除信息节点
                    root.RemoveChild(infoNode);
                    //保存xml文件
                    xmldoc.Save(xmlPath);
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 删除指定信息节点的数据节点
        /// </summary>
        /// <param name="InfoName">信息节点名</param>
        /// <param name="DataName">数据节点名</param>
        /// <returns>删除成功返回true，失败false</returns>
        public bool DeleteXml(string InfoName, string DataName)
        {
            try
            {
                //获取根节点
                XmlNode root = xmldoc.SelectSingleNode(xmlName);
                //获取信息节点
                XmlNode infoNode = root.SelectSingleNode(InfoName);
                if (infoNode != null)
                {
                    //获取数据节点
                    XmlNode dataNode = infoNode.SelectSingleNode(DataName);
                    if (dataNode != null)
                    {
                        //移除节点
                        infoNode.RemoveChild(dataNode);
                        //保存xml文件
                        xmldoc.Save(xmlPath);
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
            catch (Exception)
            {

                throw;
            }
        }

        #endregion

        #region 查询
        /// <summary>
        /// 根据数据节点名查询内部文本值
        /// </summary>
        /// <param name="dataName">数据节点名</param>
        /// <returns>查询为空则返回空字符串</returns>
        public string ReadInnerText(string dataName)
        {
            try
            {
                //获取数据节点
                XmlNode dataNode = xmldoc.SelectSingleNode("//" + dataName);
                if (dataNode != null)
                {
                    return dataNode.InnerText;
                }
                else
                {
                    return null;
                } 
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 根据信息节点名和数据节点名查询内部文本值，
        /// </summary>
        /// <param name="infoName">信息节点名</param>
        /// <param name="dataName">数据节点名</param>
        /// <returns>查询为空则返回空字符串</returns>
        public string ReadInnerText(string infoName, string dataName)
        {
            try
            {
                //获取信息节点
                XmlNode nodeNode = xmldoc.SelectSingleNode("//" + infoName);
                if (nodeNode != null)
                {
                    //获取数据节点
                    XmlNode dataNode = nodeNode.SelectSingleNode(dataName);
                    if (dataNode != null)
                    {
                        return dataNode.InnerText;
                    }
                    else
                    {
                        return null;
                    }
                }
                else
                {
                    return null;
                }
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 根据数据节点名和属性Key值查询属性Value值
        /// </summary>
        /// <param name="dataName">数据节点名</param>
        /// <param name="key">属性Key值</param>
        /// <returns>查询为空则返回空字符串</returns>
        public string ReadValueByKey(string dataName, string key)
        {
            try
            {
                //获取该节点
                XmlElement dataNode = (XmlElement)xmldoc.SelectSingleNode("//" + dataName);
                if (dataNode != null)
                {
                    //返回关键字对应value值
                    return dataNode.GetAttribute(key);
                }
                else
                {
                    return null;
                }
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 根据信息节点名、数据节点名和属性Key值查询属性Value值
        /// </summary>
        /// <param name="infoName">信息节点名</param>
        /// <param name="dataName">数据节点名</param>
        /// <param name="key">属性Key</param>
        /// <returns>查询为空则返回空字符串</returns>
        public string ReadValueByKey(string infoName, string dataName, string key)
        {
            try
            {
                //获取信息节点
                XmlNode nodeNode = xmldoc.SelectSingleNode("//" + infoName);
                if (nodeNode != null)
                {
                    //获取数据节点
                    XmlElement dataNode = (XmlElement)nodeNode.SelectSingleNode(dataName);
                    if (dataNode != null)
                    {
                        //返回关键字对应value值
                        return dataNode.GetAttribute(key);
                    }
                    else
                    {
                        return null;
                    }
                }
                else
                {
                    return null;
                }
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 根据查询节点名,获取该节点所有属性数据
        /// </summary>
        /// <param name="infoName"></param>
        /// <param name="dataName"></param>
        /// <returns>查询为空则返回空字符数组</returns>
        public string[] ReadValues(string infoName, string dataName)
        {
            try
            {
                //获取信息节点
                XmlNode nodeNode = xmldoc.SelectSingleNode("//" + infoName);
                if (nodeNode != null)
                {
                    //获取数据节点
                    XmlNode dataNode = nodeNode.SelectSingleNode(dataName);
                    List<string> values = new List<string>();
                    if (dataNode != null)
                    {
                        foreach (XmlAttribute attribute in dataNode.Attributes)
                        {
                            values.Add(attribute.Value);
                        }
                        return values.ToArray();
                    }
                    else
                    {
                        return new string[] { };
                    }
                }
                else
                {
                    return new string[] { };
                }
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 根据查询节点名,获取所有子节点的全部name和value信息
        /// </summary>
        /// <param name="nodeName">数据节点名</param>
        /// <returns>查询为空则返回空列表,List元素 (string[]{name,values})</returns>
        public List<string[]> ReadChildValues(string nodeName)
        {
            try
            {
                //获取信息节点
                XmlNode infoNode = xmldoc.SelectSingleNode("//" + nodeName);
                if (infoNode != null)
                {
                    //获取该节点的所有子节点
                    XmlNodeList childNodes = infoNode.ChildNodes;
                    //获取子节点name和values
                    List<string[]> nodesInfo = new List<string[]>();
                    foreach (XmlNode childNode in childNodes)
                    {
                        List<string> info = new List<string>();
                        info.Add(childNode.Name);
                        //遍历属性信息
                        foreach (XmlAttribute attribute in childNode.Attributes)
                        {
                            info.Add(attribute.Value);
                        }
                        nodesInfo.Add(info.ToArray());
                    }
                    return nodesInfo;

                }
                else
                {
                    return new List<string[]>();
                }
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 根据查询节点，获取所有子节点名称数组
        /// </summary>
        /// <param name="nodeName">查询节点名称</param>
        /// <returns>查询为空则返回空数组</returns>
        public string[] ReadChildNodesName(string nodeName)
        {
            try
            {
                //获取信息节点
                XmlNode infoNode = xmldoc.SelectSingleNode("//"+nodeName);
                if (infoNode != null)
                {
                    //获取该节点的所有子节点
                    XmlNodeList childNodes = infoNode.ChildNodes;
                    //获取子节点名称
                    List<string> names = new List<string>();
                    foreach (XmlNode childNode in childNodes)
                    {
                        names.Add(childNode.Name);
                    }
                    //返回名称字符串数组
                    return names.ToArray();
                }
                else
                {
                    return new string[] { };
                }
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 获取节点所在的层级
        /// </summary>
        /// <param name="nodeName"></param>
        /// <returns>在树中的返回其层级，没有该节点则返回-1</returns>
        public int ReadLevel(string nodeName)
        {
            try
            {
                //不能是数字开头的名称
                Regex rex = new Regex(@"^\d+$");
                if (nodeName != "")
                {
                    if (!rex.IsMatch(nodeName.ToArray()[0].ToString()))
                    {
                        //获取信息节点
                        XmlNode infoNode = xmldoc.SelectSingleNode("//" + nodeName);
                        if (infoNode != null)
                        {
                            //查询父节点名称
                            int level = 1;
                            while (true)
                            {
                                XmlNode parentNode = infoNode.ParentNode;
                                if (parentNode.Name == "管点" || parentNode.Name == "管线")
                                {
                                    break;
                                }
                                else
                                {
                                    level++;
                                    infoNode = parentNode;
                                }
                            }
                            //返回结果
                            return level;
                        }
                        else
                        {
                            //返回结果
                            return -1;
                        }
                    }
                    else
                    {
                        //返回结果
                        return -1;
                    }
                }
                else
                {
                    //返回结果
                    return -1;
                }

            }
            catch (Exception)
            {

                throw;
            }
        }
        #endregion
    }//class-end
}//namespace-end
